// 异步错误捕获中间件
const asyncHandler = (fn) => {
  return (req, res, next) => {
    Promise.resolve(fn(req, res, next)).catch(next);
  };
};

// 404错误处理中间件
const notFound = (req, res, next) => {
  const error = new Error(`接口不存在 - ${req.originalUrl}`);
  error.status = 404;
  next(error);
};

// 全局错误处理中间件
const errorHandler = (err, req, res, next) => {
  let error = { ...err };
  error.message = err.message;

  // 控制台输出错误信息（开发环境）
  if (process.env.NODE_ENV === 'development') {
    console.error('错误详情:', err);
  }

  // Mongoose错误处理
  if (err.name === 'CastError') {
    const message = 'ID格式无效';
    error = {
      status: 400,
      message
    };
  }

  // Mongoose重复键错误
  if (err.code === 11000) {
    let message = '数据重复';
    const field = Object.keys(err.keyValue)[0];
    const value = err.keyValue[field];
    
    if (field === 'phone') {
      message = `手机号 ${value} 已存在`;
    } else if (field === 'email') {
      message = `邮箱 ${value} 已存在`;
    } else if (field === 'orderNumber') {
      message = '工单编号重复，请重试';
    }
    
    error = {
      status: 400,
      message
    };
  }

  // Mongoose验证错误
  if (err.name === 'ValidationError') {
    const messages = Object.values(err.errors).map(val => val.message);
    error = {
      status: 400,
      message: '数据验证失败',
      errors: messages
    };
  }

  // JWT错误处理
  if (err.name === 'JsonWebTokenError') {
    error = {
      status: 401,
      message: '无效的访问令牌'
    };
  }

  if (err.name === 'TokenExpiredError') {
    error = {
      status: 401,
      message: '访问令牌已过期，请重新登录'
    };
  }

  // 文件上传错误
  if (err.code === 'LIMIT_FILE_SIZE') {
    error = {
      status: 400,
      message: '文件大小超出限制'
    };
  }

  if (err.code === 'LIMIT_FILE_COUNT') {
    error = {
      status: 400,
      message: '文件数量超出限制'
    };
  }

  // 数据库连接错误
  if (err.name === 'MongooseError' || err.name === 'MongoError') {
    error = {
      status: 500,
      message: '数据库连接错误'
    };
  }

  // 权限错误
  if (err.message && err.message.includes('permission')) {
    error = {
      status: 403,
      message: '没有权限执行此操作'
    };
  }

  // 检查响应是否已经发送
  if (res.headersSent) {
    console.error('错误处理器：响应已发送，无法处理错误:', err.message);
    return;
  }

  // 默认错误响应
  const status = error.status || err.status || 500;
  const message = error.message || '服务器内部错误';
  const errors = error.errors || null;

  try {
    res.status(status).json({
      success: false,
      message,
      code: status,
      data: errors ? { errors } : null,
      ...(process.env.NODE_ENV === 'development' && { 
        stack: err.stack,
        originalError: err.message 
      })
    });
  } catch (responseError) {
    console.error('发送错误响应时出错:', responseError.message);
  }
};

// 请求日志中间件
const requestLogger = (req, res, next) => {
  const start = Date.now();
  
  // 记录请求信息
  console.log(`📥 ${req.method} ${req.originalUrl} - ${req.ip} - ${new Date().toISOString()}`);
  
  // 监听响应完成事件
  res.on('finish', () => {
    const duration = Date.now() - start;
    const statusCode = res.statusCode;
    const statusEmoji = statusCode >= 400 ? '❌' : statusCode >= 300 ? '⚠️' : '✅';
    
    console.log(`📤 ${statusEmoji} ${req.method} ${req.originalUrl} - ${statusCode} - ${duration}ms`);
  });
  
  next();
};

// 速率限制错误处理
const rateLimitHandler = (req, res, next) => {
  res.status(429).json({
    success: false,
    message: '请求过于频繁，请稍后再试',
    code: 429,
    data: null
  });
};

module.exports = {
  asyncHandler,
  notFound,
  errorHandler,
  requestLogger,
  rateLimitHandler
};